Prof(a) Débora  C.  M.  Saade,  D.Sc.

                                                                                                                                                      NS2

Disciplina de Redes de Computadores 2017-2

Entenda o NS-2 (Network Simulator 2)

O que é?

O Network Simulator ou Simulador de Rede é um simulador de eventos discreto resultante de um projeto conhecido como VINT (Virtual InterNetwork Testbed) . Vários outros, projetos e instituições compoem o NS, entre eles: a DARPA (Defense Advanced Research Projects Agency), ISI ( Information Sciences Institute) da Universidade do Sul da California, Xerox PARC, LBNL ( Lawrence Berkeley National Laboratory) e a Universidade de Berkeley. O NS é totalmente gratuito e com código fonte aberto, disponível publicamente sob a licença GNU GPLv2 para pesquisa, desenvolvimento e uso; dando liberdade ao usuário para fazer os ajustes que precisar. O simulador oferece suporte à simulação de tecnologias de rede com e sem fio, diferentes cenários baseados nos protocolos TCP e UDP, diversas políticas de fila, caracterização de tráfego com diversas distribuições estatísticas, etc.

A programação do NS é feita em duas linguagens: C++ para a estrutura básica (protocolos, agentes, etc) e OTCL (Object-oriented Tool Command Language) para uso como frontend. OTCL é uma linguagem interpretada, desenvolvida pelo MIT ( Massachusetts Institute of Technology). As duas linguagens são necessárias pois C++, que é uma linguagem compilada e de uso tradicional, mostrou-se a ferramenta mais eficaz para a manipulação de bytes, pacotes e para implementar algoritmos que rodem um grande conjunto de dados. O OTCL facilita a realização de ajustes, durante o processo de simulação, que são necessários com certa freqüência no desenvolvimento da simulação.

                         Observação: O NS-2 deve rodar no LINUX, dessa forma, você deve verificar se sua máquina apresenta esse sistema operacional.

Exemplo da praticidade do OTCL

Durante os trabalhos, muda-se a taxa de dados de um enlace e faz-se um teste, em outro instante se altera o tamanho do enlace e faz-se um teste, depois se altera o atraso e faz-se um teste, acrescenta-se um nó e faz-se um teste. Pode-se observar um desgaste muito grande se, a cada mudança de parâmetro em uma simulação, houvesse a necessidade de se compilar o programa para testá-lo. O uso da linguagem OTCL, que é interpretada, evita esse desgaste por parte do usuário, pois há uma simplificação no processo interativo de mudar e re-executar o modelo.

Estrutura básica do NS-2

* A noção de tempo no NS é obtida através de unidades de simulação que podem ser associadas, para efeitos didáticos, a segundos;
       * A rede é construída usando nós os quais são conectados por meio de enlaces;
       * Eventos são escalonados para passar entre os nós através dos enlaces;
       * Nós e enlaces podem ter várias propriedades associadas a eles;
       * Agentes podem ser associados aos nós e eles são responsáveis pela geração de diferentes tipos de pacotes;
       * A fonte de tráfego é uma aplicação ao qual é associado um agente particular;
       * Os agentes precisam de um receptor que receberá seus pacotes;
       * No caso do agente tcp (transmission control protocol) esse receptor chama-se sink (tanque) e tem a incumbência de gerar os pacotes de reconhecimento ACK ( Acknowledge);
       * No caso do agente udp (user datagram protocol) o receptor chama-se null (nulo).

Passos básicos para desenvolver uma simulação no NS-2

Vamos descrever de forma rápida cada passo da figura abaixo, possibilitando o usuário entender a sequência necessária para se desenvolver uma simulação no NS.

* Primeiro passo: criação do objeto simulador.

            Para iniciar qualquer simulação é preciso usar a variável 'ns' no início da simulação.

                 set  ns [new simulator]

            Com isso é inicializado o formato dos pacotes, cria-se um escalonador de eventos e se seleciona o formato padrão de endereçamento.


        * Segundo passo: gerar arquivos para simulação gráfica.

            Essa parte é opcional, porém, se usada permite a criação de um arquivo trace que serve de base para animações gráficas, de acordo com o modelo simulado.


                 set  nf [open  out.nam  w]
                 $ns  namtrace-all   $nf


            No código acima, a primeira linha abre ou cria um arquivo com extensão .nam, a segunda linha do código grava e fecha os passos da simulação no arquivo out.nam.

            O arquivo out.nam será lido pela aplicação que gera as animações gráficas das simulações, ou seja, o Network Animator (NAM).


          Outras duas linhas de código podem ser usadas para possibilitar análises detalhadas das simulações; para isso, usa-se a função trace-all que grava os arquivos de trace com informações em um formato geral.

                 set  tf [open   out.tr   w]
                 $ns   trace-all   $tf



        * Terceiro passo: criar nós e enlaces.

            Definir os nós e enlaces, é definir a topologia da rede que será simulada, essa deve representar um cenário mais realístico possível. As linhas abaixo definem a criação de três nós no cenário ou modelo.


                 set  n1 [$ns   node]
                 set  n2 [$ns   node]
                 set  n3 [$ns   node]


            Deve-se criar os enlaces visando a comunicação entre os nós. Usaremos nesse caso dois enlaces full-duplex com características diferentes para ligar os três nós.


                 $ns  duplex-link  $n1  $n2  2Mb  20ms  DropTail
                 $ns  duplex-link  $n1  $n3  1Mb  10ms  DropTail


            No código acima, a primeira linha cria um enlace entre o Nó 1 e o Nó 2, com uma taxa de 2Mbit/s e um tempo de retardo (para propagação) de 20ms; a segunda linha cria um enlace entre o Nó 1 e o Nó 3, com uma taxa de 1Mbit/s e um retardo (para propagação) de 10ms. Os dois enlaces são DropTail, ou seja, os dados estão em uma fila FIFO (First In, First Out), ou seja, o primeiro pacote que entra no nó se não for transmitido e chegar outro, ele será descartado, assim gerando perda de pacotes.


        * Quarto passo: criar os agentes da camada de transporte e as suas conexões com seus nós.

         Para implementar os protocolos de transporte (TCP e UDP), deve-se criar os agentes, que são responsáveis pelas simulações destes protocolos. Os agentes criam o canal de comunicação entre o nó transmissor e o nó receptor.

             As duas primeiras linhas abaixo de código apresentam a criação de um agente UDP, anexando-o ao Nó 1 (emissor) e as outras duas linhas de código apresentam a criação de um agente TCP, anexando-o ao Nó 1 (emissor), ou seja, no mesmo nó temos duas saídas de tráfegos.


                 set  udp1 [new   Agent/UDP]
                 $ns  attach-agent  $n1  $udp1


                 set  tcp1 [new   Agent/TCP]
                 $ns  attach-agent  $n1  $tcp1


             Agora, deve-se criar os agentes receptores, cuja função é apenas receber os pacotes enviados a eles. Portanto, as duas primeiras linhas de código abaixo apresentam a criação do agente receptor (Null), anexando-o Nó 2 (receptor), e as outras duas linhas de código apresentam a criação do agente receptor (Sink), anexando-o Nó 3 (receptor).


                 set  null1 [new   Agent/Null]
                 $ns  attach-agent  $n2  $null11


                 set  sink1 [new   Agent/TCPSink]
                 $ns  attach-agent  $n3  $sink1


             As duas linhas de código abaixo efetivamente estabelecem os canais de comunicação entre o emissor Nó 1 e os receptores Nó 2 e Nó 3.


                 $ns  connect $udp1  $null1

                 $ns  connect $tcp1  $sink1


        * Quinto passo: criação dos geradores de tráfego e conexões com os agentes.

          Como os canais de comunicação já foram gerados no item acima, agora é necessário que sejam gerados os tráfegos das aplicações que usaram os canais. O código abaixo exemplifica a criação de um tráfego CBR (Constant Bit Rate), que geralmente é utilizado para streaming de áudio e/ou vídeo. Alguns parâmetros são necessários, como o tamanho do pacote (em bytes), intervalo de transmissão (em segundos), entre outros. Este será usado na transmissão dos pacotes entre o Nó 1 e Nó 2.


                 set  cbr1 [new   Application/Traffic/CBR]
                 $cbr1   set  packetSize_500
                 $cbr1   set  interval_0.005
                 $cbr1  attach-agent  $udp1


          O código abaixo exemplifica a criação de um tráfego FTP do Nó 1 ao Nó 3, onde a primeira linha é responsável por gerar o tráfego, a segunda linha define o número máximo de pacotes que o Nó 1 vai transmitir e a última linha associa a aplicação criada ao protocolo da camada de transporte TCP.


                 set  ftp1 [new   Application/FTP]
                 $ftp1   set  maxpkts_1000
                 $ftp1  attach-agent  $tcp2


        * Sexto passo: criação dos eventos de simulação.

          No código a seguir, a aplicação CBR é iniciada no tempo 0.5s e finalizada em 4.5s; depois vemos que a aplicação FTP é iniciada em 1.2s e finalizada em 4.3s. Após em 5.0s, é chamado o procedimento ‘finish’, que encerra a simulação.

                 $ns at 0.5 "$cbr1 start"
                 $ns at 4.5 "$cbr1 stop"

                 $ns at 1.2 "$ftp1 start"
                 $ns at 4.3 "$ftp1 stop"

                 $ns at 5.0 "finish"

        * Sétimo passo: geração de animações (NAM) e estatísticas (gráficos, etc..).

          O código abaixo é responsável por fechar e limpar os arquivos de traces já existentes com o mesmo nome, abrir o NAM e encerrar efetivamente a simulação. A última linha ($ns run) é responsável por executar a simulação e iniciar o escalonador de eventos do NS.

                 proc finish {} {
                 global ns nf
                 $ns flush-trace
                 close $nf
                 exec nam out.nam &
                 exit 0 }
                 $ns run

Iniciando a simulação com o arquivo gerado

Para executar a simulação usa-se o comando, abaixo, que executa a simulação e abre o NAM, caso este seja usado.

                 $ns nome_do_script.tcl

        ###############         ################         #################         ##############         ##############         ##############         ##############         ##############